home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Text⁄Files / Grep src / GrepIO.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-10-31  |  10.2 KB  |  507 lines  |  [TEXT/KAHL]
  1. /*
  2.     GrepIO - routines for treating TEXT or WORD (MacWrite)
  3.     files as a stream of characters or lines, and for output file
  4.     setup and termination.
  5. */
  6.  
  7. # include    <FileMgr.h>
  8. # include    <StdFilePkg.h>
  9. # include    "Grep.h"
  10.  
  11.  
  12. # define    bufSize    1024    /* input buffer size */
  13. # define    lineLen    65        /* output line len before break */
  14.  
  15.  
  16. typedef Byte ByteBuf[];
  17.  
  18.  
  19. typedef struct
  20. {
  21.     int        version;
  22.     int        paraOffset;
  23.     int        paraCount;
  24. } DocInfo3;
  25.  
  26. typedef struct
  27. {
  28.     int    paraType;
  29.     int    paraLen;
  30. } ParaInfo3;
  31.  
  32.  
  33. typedef struct
  34. {
  35.     long    iArrayPos;
  36.     int        iArrayLen;
  37. } DocInfo6;
  38.  
  39.  
  40. typedef struct        /* information array element */
  41. {
  42.     int        height;
  43.     int        pagePos;
  44.     long    **paraHand;
  45.     union
  46.     {
  47.         Byte    st;        /* first byte is status */
  48.         long    pos;
  49.     } stPos;
  50.     int        dataLength;
  51.     int        formats;
  52. } ParaInfo6, InfoArray[];
  53.  
  54.  
  55.  
  56. SFReply    outReply;                /* output file */
  57. SFReply    theStream;                /* SFGetFile reply record */
  58. Boolean    streamOpen = false;        /* whether stream currently open */
  59. int        streamType;                /* file type of stream */
  60. int        f;                        /* input file reference number */
  61.  
  62.  
  63. /*  vars needed for TEXT stream only */
  64.  
  65. char    filBuf[bufSize];    /* file buffer */
  66. long    fLen;
  67. int        fChars;
  68.  
  69. /*  vars needed for WORD stream only */
  70.  
  71. ByteBuf        **paraBuf = nil;
  72. InfoArray    **infoHand = nil;
  73. Boolean        compressed;
  74. Boolean        inPara;
  75. int            nParas;        /* number of paragraphs */
  76. int            paraNum;    /* current paragraph number */
  77. int            pIndex;        /* index into paragraph */
  78. int            pChars;        /* number of chars extracted from paragraph */
  79. int            pLen;        /* number of chars in paragraph */
  80.  
  81. /* decompression variables */
  82.  
  83. Boolean    firstHalf;    /* which half of current index char */
  84. Boolean    needNib;    /* true = 2nd nibble needed for ascii */
  85. Boolean    nextAsc;    /* true = two nibbles needed */
  86. Byte    lastNib;    /* holds last nibble */
  87.  
  88. /* miscellaneous */
  89.  
  90. Point    dlogWhere = { 70 /* = y */, 100 /* = x */ };
  91. OSType    type[2] = { 'WORD', 'TEXT' };
  92.  
  93.  
  94. MyFRead (p, amount)
  95. Ptr        p;
  96. long    amount;
  97. { 
  98.     (void) FSRead (f, &amount, p);
  99. }
  100.  
  101. MyFSeek (pos)
  102. long    pos;
  103. {
  104.     (void) SetFPos (f, fsFromStart, pos);
  105. }
  106.  
  107.  
  108. /*
  109.     _FSOpen - like FSOpen, but has open mode parameter.
  110.  
  111.     CloseStream - close current stream, if one is open.  Releases any
  112.         heap storage currently used, if stream is WORD type.
  113.  
  114.     OpenStream - open 'TEXT' or 'WORD' stream.
  115.         Return noErr if file opened OK, fnOpnErr or mFulErr if not.
  116.         if OK, set fileOpen true.
  117. */
  118.  
  119.  
  120. OSErr _FSOpen (fName, vRefNum, refNum, mode)
  121. StringPtr    fName;
  122. int            vRefNum;
  123. int            *refNum;
  124. int            mode;
  125. {
  126. ParamBlockRec    p;
  127. register OSErr    result;
  128.  
  129.     p.ioParam.ioNamePtr = fName;
  130.     p.ioParam.ioVRefNum = vRefNum;
  131.     p.ioParam.ioPermssn = mode;
  132.     p.ioParam.ioVersNum = 0;
  133.     p.ioParam.ioMisc = 0;
  134.     result = PBOpen (&p, false);
  135.     *refNum = p.ioParam.ioRefNum;
  136.     return (result);
  137. }
  138.  
  139.  
  140. CloseStream ()
  141. {
  142.     if (streamOpen)
  143.     {
  144.         (void) FSClose (f);
  145.         /*(void) FlushVol (nil, theStream.vRefNum);*/
  146.         streamOpen = false;
  147.         if (paraBuf != nil)
  148.         {
  149.             DisposHandle (paraBuf);
  150.             paraBuf = nil;
  151.         }
  152.         if (infoHand != nil)
  153.         {
  154.             DisposHandle (infoHand);
  155.             infoHand = nil;
  156.         }
  157.     }
  158. }
  159.  
  160.  
  161. OSErr OpenStream ()
  162. {
  163. DocInfo3        docInfo3;
  164. DocInfo6        docInfo6;
  165. register OSErr    result = fnOpnErr;
  166. register int    curRes;
  167.  
  168.     CloseStream ();            /* close any currently open stream */
  169.  
  170.     curRes = CurResFile ();
  171.     UseResFile (0);
  172.     SFGetFile (dlogWhere, "\p", nil, 2, &type, nil, &theStream);
  173.     UseResFile (curRes);
  174.     Update ();                /* refresh screen immediately */
  175.     if (theStream.good)
  176.     {
  177.         if (_FSOpen (theStream.fName, theStream.vRefNum,
  178.                                     &f, fsRdPerm) == noErr)
  179.         {
  180.             streamOpen = true;
  181.             result = noErr;
  182.         }
  183.     }
  184.  
  185.     if (result == noErr)        /* so far, so good */
  186.     {
  187.         if (theStream.fType == 'TEXT')
  188.         {
  189.             streamType = text;
  190.             fChars = 0;    /* set these to trigger a read on the first */
  191.             fLen = 0;    /* call to StreamGetC() */
  192.         }
  193.         else    /* must be WORD file - determine version */
  194.         {
  195.             paraBuf = (ByteBuf **) NewHandle (0L);
  196.             MyFRead (&docInfo3, (long) sizeof (DocInfo3));
  197.  
  198.             if (docInfo3.version == 3)        /* MacWrite 2.2 file */
  199.             {
  200.                 streamType = mwrt3;
  201.                 nParas = docInfo3.paraCount;
  202.                 MyFSeek ((long) docInfo3.paraOffset);
  203.             }
  204.             else if (docInfo3.version == 6)    /* MacWrite 4.5 file */
  205.             {
  206.                 streamType = mwrt6;
  207.                 MyFSeek (264L);        /* 252 + 12 */
  208.                 MyFRead (&docInfo6, (long) sizeof (DocInfo6));
  209.                 MyFSeek (docInfo6.iArrayPos);
  210.                 infoHand = (InfoArray **) NewHandle (docInfo6.iArrayLen);
  211.                 if (infoHand == nil)
  212.                 {
  213.                     CloseStream ();
  214.                     result = mFulErr;
  215.                 }
  216.                 else
  217.                 {
  218.                     HLock (infoHand);
  219.                     MyFRead (*infoHand, (long) docInfo6.iArrayLen);
  220.                     HUnlock (infoHand);
  221.                     nParas = docInfo6.iArrayLen / sizeof (ParaInfo6);
  222.                 }
  223.             }
  224.             else
  225.             {
  226.                 CloseStream ();
  227.                 Alarm ("\pFile created by unsupported MacWrite version");
  228.                 result = fnOpnErr;
  229.             }
  230.             paraNum = -1;
  231.             inPara = false;            /* not in any paragraph yet */
  232.         }
  233.     }
  234.     return (result);
  235. }
  236.  
  237.  
  238. Boolean GetStream ()
  239. {
  240.  
  241.     if (OpenStream () != noErr)
  242.         return (false);
  243.     DisplayString (theStream.fName);
  244.     DisplayString ("\p (");
  245.     DisplayString (streamType == text ? "\pText" : "\pMacWrite");
  246.     DisplayString ("\p file)\r");
  247.     return (true);
  248. }
  249.  
  250.  
  251. /*
  252.     _Decompress takes a nibble at a time of compressed text.  If more
  253.     nibbles are needed to complete the next character, return -1, else
  254.     returns the character.
  255. */
  256.        
  257. _Decompress (b)
  258. Byte    b;
  259. {
  260. register int    result = -1;
  261.  
  262.     if (needNib)                /* Low half of ascii nibble is needed. */
  263.     {
  264.         needNib = false;
  265.         result = lastNib | b;    /* Put the two halves together */
  266.     }
  267.     else if (nextAsc)            /* Two nibbles are needed */
  268.     {
  269.         nextAsc = false;
  270.         lastNib = b << 4;        /* Save this one as the high nibble */
  271.         needNib = true;            /* Need one more nibble */
  272.     }
  273.     else if (b == 15)            /* Nibble of 15 means the next char is ascii */
  274.         nextAsc = true;
  275.     else            /* Add the nibble value to the English decompression */
  276.                     /* key (saved as Resource Type 'STR ' 700 in file)   */
  277.                     /* to get the proper character */
  278.     {
  279.         result = " etnroaisdlhcfp" [b];    /* note: C string */
  280.     }
  281.     return (result);
  282. }
  283.  
  284.  
  285. Boolean ReadParaBuf ()
  286. {
  287.     SetHandleSize (paraBuf, pLen);        /* make big enough */
  288.     if (MemError () != noErr)
  289.     {
  290.         Alarm ("\pCan't read paragraph buffer");
  291.         paraNum = nParas;    /* force stream close and exit of GetC loop */
  292.         return (false);
  293.     }
  294.     HLock (paraBuf);
  295.     MyFRead (*paraBuf, (long) pLen);
  296.     HUnlock (paraBuf);
  297.     return (true);
  298. }
  299.  
  300.  
  301. WordStreamGetC ()        /* return -1 on EOF */
  302. {
  303. register int    c;
  304. register int    result;
  305. ParaInfo3        paraInfo3;
  306.  
  307.     if (!inPara)        /* must read in next paragraph */
  308.     {
  309.         for (;;)
  310.         {
  311.             if (++paraNum >= nParas)
  312.             {
  313.                 CloseStream ();
  314.                 return (-1);
  315.             }
  316.             if (streamType == mwrt3)
  317.             {
  318.                 MyFRead (¶Info3, (long) sizeof (ParaInfo3));
  319.                 pLen = paraInfo3.paraLen;
  320.                 if (ReadParaBuf () == false)
  321.                     continue;
  322.                 if (paraInfo3.paraType != 1)
  323.                 {
  324.                     continue;    /* not text */
  325.                 }
  326.                 /* adding two skips length word */
  327.                 if ((pLen = ((int *) **paraBuf)[0] + 2) == 2)
  328.                     continue;    /* empty paragraph */
  329.                 pChars = 2;
  330.                 compressed = false;
  331.                 inPara = true;
  332.                 break;
  333.             }
  334.             else    /* mwrt6 */
  335.             {
  336.                 if ((**infoHand)[paraNum].height <= 0)
  337.                 {
  338.                     continue;    /* not text */
  339.                 }
  340.  
  341. /*
  342.     Seek to this paragraph's data (must mask the high byte to get the
  343.     correct value).  Move to the paragraph, get its length, make
  344.     the pointer big enough, and read it in.  (skip to next para if this
  345.     one is empty, though.)
  346.     compressed will be set true if the paragraph is compressed.
  347. */
  348.  
  349.                 MyFSeek ((**infoHand)[paraNum].stPos.pos & 0x00FFFFFF);
  350.                 MyFRead (&pLen, (long) sizeof (int));    /* get length */
  351.                 if (pLen == 0)
  352.                 {
  353.                     continue;                        /* empty para - skip */
  354.                 }
  355.                 if (ReadParaBuf () == false)
  356.                     continue;
  357.                 compressed = ((**infoHand)[paraNum].stPos.st >> 3) & 1;
  358.                 inPara = true;
  359.                 nextAsc = false;
  360.                 needNib = false;
  361.                 pIndex = 0;        /* index into current paragraph */
  362.                 pChars = 0;        /* chars extracted from current paragraph */
  363.                 firstHalf = true;    /* use first half of current index char */
  364.                 break;
  365.             }
  366.         }
  367.     }
  368.  
  369. /*
  370.     At this point, know either that we have a new non-empty paragraph, or
  371.     are still in the previous one.
  372. */
  373.  
  374.     if (!compressed)    /* uncompressed */
  375.     {
  376.         c = (**paraBuf)[pChars];
  377.     }
  378.     else
  379.     {
  380.         do
  381.         {
  382.             c = (**paraBuf)[pIndex];
  383.             if (firstHalf)
  384.             {
  385.                 c = _Decompress (((Byte) c) >> 4);
  386.             }
  387.             else
  388.             {
  389.                 c = _Decompress ((Byte) (c & 0x0f));
  390.                 ++pIndex;    /* go to next char at next index */
  391.             }
  392.             firstHalf = !firstHalf;
  393.         } while (c == -1);
  394.     }
  395.     if (++pChars >= pLen)    /* see if need new paragraph next time */
  396.         inPara = false;
  397.     return (c);
  398. }
  399.  
  400.  
  401. /*
  402.     StreamGetC - get character from stream.
  403. */
  404.  
  405. StreamGetC ()
  406. {
  407.  
  408.     if (!streamOpen)
  409.         return (-1);
  410.  
  411.     if (streamType != text)
  412.         return (WordStreamGetC ());
  413.  
  414.     if (fChars >= fLen)    /* need to read in a new block */
  415.     {
  416.         fLen = bufSize;
  417.         (void) FSRead (f, &fLen, filBuf);
  418.         if (fLen == 0)
  419.         {
  420.             CloseStream ();
  421.             return (-1);
  422.         }
  423.         fChars = 0;
  424.     }
  425.     return (filBuf[fChars++]);
  426. }
  427.  
  428.  
  429. /*
  430.     StreamGetS - get string from stream.
  431.  
  432.     Returns nil if no string obtained, otherwise a pointer to the argument.
  433. */
  434.  
  435. StringPtr StreamGetS (s)
  436. register StringPtr    s;
  437. {
  438. register int        c;
  439. register StringPtr    result = nil;
  440.  
  441.     s[0] = 0;    /* clear string */
  442.     while ((c = StreamGetC ()) != -1)
  443.     {
  444.         result = s;    /* got something, so StreamGetS succeeds */
  445.         if (c == '\r' || (s[0] > lineLen && c == ' '))
  446.             break;
  447.         s[++s[0]] = c;        /* add char to end */
  448.     }
  449.     return (result);
  450. }
  451.  
  452.  
  453.  
  454. FileOutput ()
  455. {
  456. FInfo                f;
  457. long                pos;
  458. register int        curRes;
  459.  
  460.     if (fileOpen)    /* close it */
  461.     {
  462.         fileOpen = false;
  463.         (void) GetFPos (outFile, &pos);
  464.         (void) SetEOF (outFile, pos);
  465.         (void) FSClose (outFile);
  466.         (void) FlushVol (nil, outReply.vRefNum);
  467.         SetItem (theMenu, saveOutput, "\pSave Output...");
  468.     }
  469.     else
  470.     {
  471.         curRes = CurResFile ();
  472.         UseResFile (0);
  473.         SFPutFile (dlogWhere, "\pWrite To...", "\p", nil, &outReply);
  474.         UseResFile (curRes);
  475.         Update ();            /* refresh screen immediately */
  476.         if (outReply.good)
  477.         {
  478.             if (GetFInfo (outReply.fName, outReply.vRefNum, &f) == noErr) /* exists */
  479.             {
  480.                 if (f.fdType != 'TEXT')
  481.                 {
  482.                     Alarm ("\pNot a TEXT File");
  483.                     return;
  484.                 }
  485.             }
  486.             else    /* doesn't exist.  create it. */
  487.             {
  488.                 if (Create (outReply.fName, outReply.vRefNum,
  489.                             'Grep', 'TEXT') != noErr)
  490.                 {
  491.                     Alarm ("\pCan't Create");
  492.                     return;
  493.                 }
  494.             }
  495.  
  496.             if (_FSOpen (outReply.fName, outReply.vRefNum,
  497.                                 &outFile, fsWrPerm) != noErr)
  498.                 Alarm ("\pCan't Open");
  499.             else
  500.             {
  501.                 fileOpen = true;
  502.                 SetItem (theMenu, saveOutput, "\pStop Saving Output");
  503.             }
  504.         }
  505.     }
  506. }
  507.